//===============================================================================
// Microsoft patterns & practices
// Composite Application Guidance for Windows Presentation Foundation
//===============================================================================
// Copyright (c) Microsoft Corporation.  All rights reserved.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================
// The example companies, organizations, products, domain names,
// e-mail addresses, logos, people, places, and events depicted
// herein are fictitious.  No association with any real company,
// organization, product, domain name, email address, logo, person,
// places, or events is intended or should be inferred.
//===============================================================================

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Modularity.AcceptanceTests.TestInfrastructure;

namespace Modularity.AcceptanceTests.Helpers
{
    public static class HelperExtensions
    {
        private static List<Module> sortedList = new List<Module>();

        public static List<Module> SortModulesInLoadOrder(this List<Module> lm)
        {
            foreach (Module m in lm)
            {
                if (m.Dependencies.Count == 0 && !sortedList.Contains(m))
                {
                    sortedList.Add(m);
                }
                else
                {
                    foreach (string dependency in m.Dependencies)
                    {
                        lm.SortModulesInLoadOrder(dependency);
                    }

                    if (!sortedList.Contains(m))
                    {
                        sortedList.Add(m);
                    }
                }
            }

            return sortedList;
        }

        public static List<Module> SortModulesInLoadOrder(this List<Module> lm, string moduleName)
        {
            Module mod;

            if (null != moduleName && moduleName.Length > 0)
            {
                mod = lm.Find(l => l.ModuleName.Equals(moduleName));
                if (mod.Dependencies.Count == 0 && !sortedList.Contains(mod))
                {
                    sortedList.Add(mod);
                }
                else
                {
                    foreach (string dependency in mod.Dependencies)
                    {
                        lm.SortModulesInLoadOrder(dependency);
                    }

                    if (!sortedList.Contains(mod))
                    {
                        sortedList.Add(mod);
                    }
                }
            }
            else
            {
                foreach (Module m in lm)
                {
                    if (m.Dependencies.Count == 0 && !sortedList.Contains(m))
                    {
                        sortedList.Add(m);
                    }
                    else
                    {
                        foreach (string dependency in m.Dependencies)
                        {
                            lm.SortModulesInLoadOrder(dependency);
                        }

                        if (!sortedList.Contains(m))
                        {
                            sortedList.Add(m);
                        }
                    }
                }
            }

            return sortedList;
        }
    }
}
